home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / QuickDraw GX / QuickDraw GX Info / QuickDraw GX Interfaces / Interfaces & Libraries / graphics libraries / storage library.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-30  |  7.2 KB  |  263 lines  |  [TEXT/MPS ]
  1. /* graphics libraries:  
  2.    primitive flattening library routines
  3.    by Cary Clark, Georgiann Delaney, Michael Fairman, Dave Good, Robert Johnson, Keith McGreggor, Oliver Steele, David Van Brink, Chris Yerga
  4.    Copyright 1987 - 1991 Apple Computer, Inc.  All rights reserved.  */
  5.  
  6.  
  7.    #include <Memory.h>
  8.    #include <Errors.h>
  9.    #include <Files.h>
  10. #include "font routines.h"
  11. #include "graphics libraries.h"
  12. #include "scaler types.h"
  13. #include "storage library.h"
  14. /*
  15.    The following routine is an example of how to write a spooling procedure to
  16.    work with GXFlattenShape and GXUnflattenShape.  For writing, it stores the data in
  17.    a Handle which must be disposed of after the GXFlattenShape call.  When reading,
  18.    it expects the 'data' field of the gxSpoolBlock to have a handle to the data to be
  19.    unflattened.
  20. */
  21.  
  22. #define allocationIncrement   1024     /* the storage handle is grown by this amount */
  23.  
  24. #ifdef __cplusplus
  25. extern "C" {
  26. #endif
  27.  
  28. static long HandleSpoolProc(gxSpoolCommand command,  userSpool *block)
  29. {
  30.    switch (command)
  31.    {
  32.       case gxOpenReadSpool:
  33.          block->size = 0;
  34.          block->position = 0;
  35.       break;
  36.       case gxOpenWriteSpool:
  37.          block->data = NewHandle(allocationIncrement);
  38.          block->size = allocationIncrement;
  39.          block->position = 0;
  40.       break;
  41.       
  42.       case gxReadSpool:
  43.          BlockMove((*(char **) block->data) + block->position, block->spool.buffer, block->spool.count);
  44.          block->position += block->spool.count;
  45.       break;
  46.  
  47.       case gxWriteSpool:
  48.       {  register long oldPosition;
  49.  
  50.          oldPosition = block->position;
  51.          block->position += block->spool.count;
  52.  
  53.          /* make sure there is at least enough room for one buffer size past current pointer */
  54.          if (block->position + block->spool.bufferSize > block->size)      
  55.          {
  56.             block->size += block->spool.bufferSize;
  57.             HUnlock((Handle) block->data);
  58.             SetHandleSize((Handle) block->data, block->size);
  59.             HLock((Handle) block->data);
  60.          }
  61.          BlockMove(block->spool.buffer, (*(char **) block->data + oldPosition), block->spool.count);
  62.       }
  63.       break;
  64.       
  65.       case gxCloseSpool:
  66.          SetHandleSize((Handle) block->data, block->position);
  67.       break;
  68.    }
  69.    return 0;
  70. }
  71.  
  72. #ifdef __cplusplus
  73. }
  74. #endif
  75.  
  76. /*
  77.    This routine spools to and from a file.  The file must have previously been created and opened,
  78.    and its refNum is expected to be in the refnum field of the block.
  79. */
  80. static long FileSpoolProc(gxSpoolCommand command, userSpool *block)
  81. {
  82.    short err;
  83.    
  84.    switch (command) {
  85.       case gxOpenReadSpool:
  86.       break;
  87.       case gxOpenWriteSpool:
  88.       break;
  89.       case gxReadSpool:
  90.       {
  91.          long count = block->spool.count;
  92.          err = FSRead(block->reference, &count, block->spool.buffer);
  93.          IfDebug(err && err != eofErr, "\pFSRead failed");
  94.       } break;
  95.       case gxWriteSpool:
  96.       {
  97.          long count = block->spool.count;
  98.          err = FSWrite(block->reference, &count, block->spool.buffer);
  99.          IfDebug(err, "\pFSWrite failed");
  100.       } break;
  101.       case gxCloseSpool:
  102.       break;
  103.       default:
  104.          IfDebug(true, "\punexpected spool command");
  105.    }
  106.    return 0;
  107. }
  108.  
  109. Handle ShapeToHandle(gxShape source)
  110. {
  111.    userSpool block;
  112.    
  113.    NilShapeReturnNil(source);
  114. #ifndef __powerc
  115.    block.spool.spoolProcedure = (gxSpoolProcPtr) HandleSpoolProc;
  116. #else
  117.    block.spool.spoolProcedure = NewgxSpoolProc(HandleSpoolProc);
  118. #endif
  119.    block.spool.buffer = nil;
  120.    block.spool.bufferSize = 0;
  121.    GXFlattenShape(source, gxFontListFlatten | gxFontGlyphsFlatten, &block.spool);
  122. #ifdef __powerc
  123.    DisposeRoutineDescriptor(block.spool.spoolProcedure);
  124. #endif
  125.    return (Handle) block.data;
  126. }
  127.  
  128. gxShape HandleToShape(Handle source, long count, const gxViewPort portList[])
  129. {
  130.    userSpool block;
  131.    gxShape dest;
  132.    
  133. #ifndef __powerc   
  134.    block.spool.spoolProcedure = (gxSpoolProcPtr) HandleSpoolProc;
  135. #else
  136.    block.spool.spoolProcedure = NewgxSpoolProc(HandleSpoolProc);
  137. #endif
  138.    block.spool.buffer = nil;
  139.    block.spool.bufferSize = 0;
  140.    block.data = source;
  141.    dest = GXUnflattenShape(&block.spool, count, portList);
  142. #ifdef __powerc
  143.    DisposeRoutineDescriptor(block.spool.spoolProcedure);
  144. #endif
  145.    return dest;
  146. }
  147.  
  148. void ShapeToFRef(gxShape source, short refNum)
  149. {
  150.     userSpool block;
  151.  
  152.     NilShapeReturn(source);
  153. #ifndef __powerc    
  154.     block.spool.spoolProcedure = (gxSpoolProcPtr) FileSpoolProc;
  155. #else
  156.     block.spool.spoolProcedure = NewgxSpoolProc(FileSpoolProc);
  157. #endif
  158.     block.reference = refNum;
  159.     block.spool.buffer = nil;
  160.     block.spool.bufferSize = 0;
  161.     GXFlattenShape(source,  gxFontListFlatten | gxFontGlyphsFlatten, &block.spool);
  162. #ifdef __powerc
  163.     DisposeRoutineDescriptor(block.spool.spoolProcedure);
  164. #endif
  165. }
  166.  
  167. gxShape FRefToShape(short refNum, long count, const gxViewPort portList[])
  168. {
  169.     userSpool block;
  170.     gxShape dest;
  171.     
  172. #ifndef __powerc    
  173.     block.spool.spoolProcedure = (gxSpoolProcPtr) FileSpoolProc;
  174. #else
  175.     block.spool.spoolProcedure = NewgxSpoolProc(FileSpoolProc);
  176. #endif
  177.     block.reference = refNum;
  178.     block.spool.buffer = nil;
  179.     block.spool.bufferSize = 0;
  180.     dest = GXUnflattenShape(&block.spool, count, portList);
  181. #ifdef __powerc
  182.     DisposeRoutineDescriptor(block.spool.spoolProcedure);
  183. #endif
  184.     return dest;
  185. }
  186.  
  187. void ShapeToFile(gxShape source, Str255 fileName, short vRefNum, OSType creator, OSType fileType)
  188. {
  189.     short refNum;
  190.     short err;
  191.     
  192.     NilShapeReturn(source);
  193.     NilParamReturn(fileName);
  194.     
  195.     if (creator == 0) creator = 'sLib';
  196.     if (fileType == 0) fileType = 'flat';
  197.     err = Create(fileName, vRefNum, creator, fileType);
  198.     if (err == dupFNErr) {
  199.         FSDelete(fileName, vRefNum);
  200.         err = Create(fileName, vRefNum, creator, fileType);
  201.     }
  202.     IfDebug(err, "\pCreate failed");
  203.     err = FSOpen(fileName, vRefNum, &refNum);
  204.     IfDebug(err, "\pFSOpen failed");
  205.     ShapeToFRef(source, refNum);
  206.     err = FSClose(refNum);
  207.     IfDebug(err, "\pFSClose failed");
  208. }
  209.  
  210. gxShape FileToShape(Str255 fileName, short vRefNum, long count, const gxViewPort portList[])
  211. {
  212.     short refNum;
  213.     short err;
  214.     gxShape dest;
  215.     
  216.     err = FSOpen(fileName, vRefNum, &refNum);
  217.     IfDebug(err, "\pFSOpen failed");
  218.     dest = FRefToShape(refNum, count, portList);
  219.     err = FSClose(refNum);
  220.     IfDebug(err, "\pFSClose failed");
  221.     return dest;
  222. }
  223.  
  224. Handle FontToHandle(gxFont fontID, long glyphBits[])
  225. {
  226.    userSpool block;
  227.    scalerStream stream;
  228.    
  229. #ifndef __powerc   
  230.    block.spool.spoolProcedure = (gxSpoolProcPtr) HandleSpoolProc;
  231. #else
  232.    block.spool.spoolProcedure = NewgxSpoolProc(HandleSpoolProc);
  233. #endif
  234.    block.spool.buffer = nil;
  235.    block.spool.bufferSize = 0;
  236.  
  237.    stream.streamRefCon = fontID;
  238.    stream.types = type1StreamType;        // flattenedStreamType;
  239.    stream.action = downloadStreamAction;
  240.    stream.memorySize = 0;
  241.    stream.variationCount = selectAllVariations;
  242.    stream.variations = nil;
  243.    stream.info.font.encoding = 0;
  244.    stream.info.font.glyphBits = glyphBits;
  245.    stream.info.font.name = (char*)"\pSkia-ps";
  246.  
  247.    GXFlattenFont(fontID, &stream, &block.spool);
  248. #ifdef __powerc
  249.    DisposeRoutineDescriptor(block.spool.spoolProcedure);
  250. #endif
  251.    return (Handle) block.data;
  252. }
  253.  
  254. gxFont HandleToFont(Handle source)
  255. {
  256.    /*
  257.     * GXNewFont does not copy the data in source, so you can't dispose
  258.     * of it until you have called GXDisposeFont().
  259.    */
  260.    return GXNewFont(gxHandleFontStorage, source, 0);
  261. }
  262.  
  263.